package com.chart.web.controller.chart.sta;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 此处写该类描述
 *
 * @author 罗继全
 * 2024/8/4 0:36
 */


public class JsonsUtil {



    //不处理空字符串
    private static List<List<String>> extractDataFromList(List<Map<String, Object>> dataList) {
        List<List<String>> extractedData = new ArrayList<>();

        for (Map<String, Object> row : dataList) {

            List<String> rowData = new ArrayList<>();
            for (Map.Entry<String, Object> entry : row.entrySet()) {
                rowData.add(entry.getValue().toString());
            }

            extractedData.add(rowData);
        }
        return extractedData;
    }

    //如果传入的有空字符串设置为0
    public static List<List<String>> extractDataFromListNullString(List<Map<String, Object>> dataList) {
        List<List<String>> extractedData = new ArrayList<>();

        for (Map<String, Object> row : dataList) {
            List<String> rowData = new ArrayList<>();
            for (Map.Entry<String, Object> entry : row.entrySet()) {
                Object value = entry.getValue();
                // 检查值是否为 null 或空字符串，并进行处理
                if (value == null || value.toString().isEmpty()) {
                    rowData.add("0"); // 为空或 null 时添加默认值 "0"
                } else {
                    rowData.add(value.toString());
                }
            }
            extractedData.add(rowData);
        }
        return extractedData;
    }


    /**
     * series
     * 先删除series中的每个对象 复制 series 的第一个对象 根据入参的seriesName的数量进行复制
     * 更新series 中的每个对象的name字段替换为 传来的seriesName
     */
    public static ObjectNode updateSeriesInJson(String chartValue, List<String> seriesName) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(chartValue);
        JsonNode path = jsonNode.path("series");

        // 统计需要复制的数量
        int size = seriesName.size();
        List<ObjectNode> duplicatedSeries = new ArrayList<>();

        // 复制 series 的第一个对象
        for (int i = 0; i < size; i++) {
            duplicatedSeries.add((ObjectNode) path.get(0).deepCopy());
        }
        // 创建新的 JSON 结构并替换 series 部分
        ObjectNode updatedJson = (ObjectNode) jsonNode.deepCopy();
        ArrayNode newSeriesArray = objectMapper.createArrayNode();
        newSeriesArray.addAll(duplicatedSeries);
        updatedJson.set("series", newSeriesArray);

        // 更新 series 中每个对象的 name 字段和 datasetIndex 字段
        for (int i = 0; i < duplicatedSeries.size(); i++) {
            duplicatedSeries.get(i).put("name", seriesName.get(i));
            duplicatedSeries.get(i).put("datasetIndex", i);
        }

        return updatedJson;
    }

    /**
     * series
     * 先删除series中的每个对象 复制 series 的第一个对象 根据入参的seriesName的数量进行复制
     * 更新series 中的每个对象的name字段替换为 传来的seriesName
     * 更新series 里面的color
     */

    public static ObjectNode updateSeriesInJsonColor(String chartValue, List<String> seriesName) throws Exception {
       // 目的是根据传入的 seriesName 列表，复制 series 中的第一个对象，并为每个复制的对象设置新的 name 和 datasetIndex，最终返回更新后的 JSON 结构。

        //获取series
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(chartValue);
        JsonNode path = jsonNode.path("series");

        // 统计需要复制的数量 准备复制操作：
        int size = seriesName.size(); //每个集合的数量
        List<ObjectNode> duplicatedSeries = new ArrayList<>();


        // 复制 series 的第一个对象
        for (int i = 0; i < size; i++) {
            duplicatedSeries.add(path.get(0).deepCopy());
        }

        // 创建新的 JSON 结构并替换 series 部分
        ObjectNode updatedJson = jsonNode.deepCopy();
        ArrayNode newSeriesArray = objectMapper.createArrayNode();
        newSeriesArray.addAll(duplicatedSeries);
        updatedJson.set("series", newSeriesArray);

        // 更新 series 中每个对象的 name 字段和 datasetIndex 字段
        for (int i = 0; i < duplicatedSeries.size(); i++) {
            duplicatedSeries.get(i).put("name", seriesName.get(i));
            duplicatedSeries.get(i).put("datasetIndex", i);
        }

        return updatedJson;
    }






     /*    要求保留series的第一个对象和最后一个对象     先删除series中剩余的对象 复制 series 的第一个对象 根据入参的seriesName的数量进行复制
        更新series 中的对象的name字段替换为 传来的seriesName*/



    public static ObjectNode updateSeriesInJsonsavaLastOne(String chartValue, List<String> seriesName) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(chartValue);
        JsonNode path = jsonNode.path("series");

        // 统计需要复制的数量
        int size = seriesName.size();
        List<ObjectNode> duplicatedSeries = new ArrayList<>();

        // 复制 series 的第一个对象，跳过最后一个对象
        for (int i = 0; i < size; i++) {
            duplicatedSeries.add((ObjectNode) path.get(0).deepCopy());
        }

        // 获取并保留 series 的最后一个对象
        JsonNode lastSeriesObject = path.get(path.size() - 1);

        // 创建新的 JSON 结构并替换 series 部分
        ObjectNode updatedJson = (ObjectNode) jsonNode.deepCopy();
        ArrayNode newSeriesArray = objectMapper.createArrayNode();
        newSeriesArray.addAll(duplicatedSeries);
        newSeriesArray.add(lastSeriesObject); // 添加最后一个对象
        updatedJson.set("series", newSeriesArray);

        // 更新 series 中每个对象的 name 字段和 datasetIndex 字段
        for (int i = 0; i < duplicatedSeries.size(); i++) {
            duplicatedSeries.get(i).put("name", seriesName.get(i));
            duplicatedSeries.get(i).put("datasetIndex", i);
        }

        return updatedJson;
    }

    /**
     * 切面
     * @param chartValue
     * @param seriesName
     * @return
     * @throws Exception
     */
    public static ObjectNode updateSeriesInJsonCut(String chartValue, List<String> seriesName) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(chartValue);
        JsonNode path = jsonNode.path("series");

        // 统计需要保留的对象
        int size = path.size();
        if (size < 2) {
            // 如果 series 中对象数量少于 2，直接返回原始 JSON
            return (ObjectNode) jsonNode.deepCopy();
        }

        // 保留第一个和最后一个对象
        ObjectNode firstSeries = (ObjectNode) path.get(0).deepCopy();
        ObjectNode lastSeries = (ObjectNode) path.get(size - 1).deepCopy();

        // 复制 series 的第一个对象
        List<ObjectNode> duplicatedSeries = new ArrayList<>();
        int seriesCount = seriesName.size();
        for (int i = 0; i < seriesCount; i++) {
            duplicatedSeries.add((ObjectNode) firstSeries.deepCopy());
        }

        // 创建新的 JSON 结构并替换 series 部分
        ObjectNode updatedJson = (ObjectNode) jsonNode.deepCopy();
        ArrayNode newSeriesArray = objectMapper.createArrayNode();
        newSeriesArray.add(firstSeries);  // 添加第一个对象
        newSeriesArray.addAll(duplicatedSeries);  // 添加复制的对象
        newSeriesArray.add(lastSeries);  // 添加最后一个对象
        updatedJson.set("series", newSeriesArray);

        // 更新 duplicatedSeries 中每个对象的 name 字段
        for (int i = 0; i < duplicatedSeries.size(); i++) {
            duplicatedSeries.get(i).put("name", seriesName.get(i));
            duplicatedSeries.get(i).put("datasetIndex", i);
        }

        return updatedJson;
    }



    public static void updateLegendNames(ObjectNode updatedJson, List<String> seriesName) {
        // 获取 legend 节点
        JsonNode legendArray = updatedJson.get("legend");
        if (legendArray != null && legendArray.isArray()) {
            for (JsonNode legend : legendArray) {
                if (legend != null && legend.isObject()) {
                    // 获取 legend 中的 data 节点
                    JsonNode data = legend.get("data");
                    if (data != null && data.isArray()) {
                        ArrayNode dataArray = (ArrayNode) data;
                        // 清空数组
                        dataArray.removeAll();
                        // 根据 seriesName 更新 data 数组
                        for (String name : seriesName) {
                            ObjectNode newNode = JsonNodeFactory.instance.objectNode();
                            newNode.put("name", name);
                            dataArray.add(newNode);
                        }
                    } else {
                        // 如果 data 不存在或者不是数组，则创建新的 data 数组并添加 name 字段
                        ArrayNode newArray = JsonNodeFactory.instance.arrayNode();
                        for (String name : seriesName) {
                            ObjectNode newNode = JsonNodeFactory.instance.objectNode();
                            newNode.put("name", name);
                            newArray.add(newNode);
                        }
                        // 添加新的 data 字段到 legend
                        ((ObjectNode) legend).set("data", newArray);
                    }
                }
            }
        }
    }

    /**
     * 更新 legend 中 data 数组的 name 字段
     * 获取legend的第一个对象 获取里面的data 保留data的第一个值 删除剩余的值 然后根据seriesName的size进行复制 然后放入data的name的值
     */
    public static void updateLegendDataNames(ObjectNode updatedJson, List<String> seriesName) {
        // 获取 legend 节点
        JsonNode legendArray = updatedJson.get("legend");
        if (legendArray != null && legendArray.isArray()) {
            for (JsonNode legend : legendArray) {
                if (legend != null && legend.isObject()) {
                    // 获取 legend 中的 data 节点
                    JsonNode data = legend.get("data");
                    if (data != null && data.isArray()) {
                        ArrayNode dataArray = (ArrayNode) data;
                        // 清空数组
                        dataArray.removeAll();
                        // 复制 seriesName.size() 次，并更新 name
                        for (String name : seriesName) {
                            ObjectNode newNode = JsonNodeFactory.instance.objectNode();
                            newNode.put("name", name);
                            dataArray.add(newNode);
                        }
                    } else {
                        // 如果 data 不是数组或者为空，则创建一个新的数组并添加 name 字段
                        ArrayNode newArray = JsonNodeFactory.instance.arrayNode();
                        for (String name : seriesName) {
                            ObjectNode newNode = JsonNodeFactory.instance.objectNode();
                            newNode.put("name", name);
                            newArray.add(newNode);
                        }
                        ((ObjectNode) legend).set("data", newArray);
                    }
                }
            }
        }
    }



    public static void updateLegendData(JsonNode legend, List<List<String>> lists) {
        if (legend.isArray() && legend.size() > 0) {
            JsonNode legendNode = legend.get(0); // 获取第一个legend对象

            if (legendNode.has("data") && legendNode.get("data").isArray() && !lists.isEmpty() && !lists.get(0).isEmpty()) {
                ArrayNode dataArray = (ArrayNode) legendNode.withArray("data");
                dataArray.removeAll(); // 删除data中的原有数据

                List<String> firstRow = lists.get(0);
                for (String value : firstRow) {
                    ObjectNode newDataNode = dataArray.addObject();
                    newDataNode.put("name", value);
                }


            }
        }
    }
    /**
     * 特殊
     * dataList
     * 特殊3D
     * 根据入参的 dataList 生成所需的 dataset 格式
     * 修改dataset里面的数据 第一个对象的第二个元素 和第二个对象的第一个元素 第二个对象的第二个元素
     * 第一个对象的第三个个元素            和第二个对象的第一个元素 第二个对象的第二个元素
     */
    public static ArrayNode generateDataset(List<List<String>> dataList) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        ArrayNode datasetArray = objectMapper.createArrayNode();

        // 第一行是列名，后面的行是数据
        List<String> columns = dataList.get(0);
        List<List<String>> dataRows = dataList.subList(1, dataList.size());

        for (List<String> row : dataRows) {
            ArrayNode sourceArray = objectMapper.createArrayNode();
            for (int i = 1; i < columns.size(); i++) {
                ArrayNode itemArray = objectMapper.createArrayNode();
                itemArray.add(columns.get(i));
                itemArray.add(row.get(0));
                itemArray.add(Double.parseDouble(row.get(i)));

                sourceArray.add(itemArray);
            }

            ObjectNode datasetObject = objectMapper.createObjectNode();
            datasetObject.set("source", sourceArray);
            datasetObject.put("seriesLayoutBy", "column");

            datasetArray.add(datasetObject);
        }

        return datasetArray;
    }


    /**
     * 普通的dataset
     * 更新
     * 更新传入的JSON对象中的dataset节点，将其source字段替换为新的数据getdata
     */
    public static void updateDatasetSource1(ObjectNode updatedJson, List<List<String>> getdata, ObjectMapper mapper) {
        ArrayNode datasetArray = (ArrayNode) updatedJson.path("dataset");
        for (JsonNode node : datasetArray) {
            if (node.has("source")) {
                ((ObjectNode) node).set("source", mapper.valueToTree(getdata));
                break;
            }
        }
    }

    //普通
    public static JsonNode updateDataset(String chartValue, List<List<String>> dataList) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode chartValueJson = objectMapper.readTree(chartValue);

        // 获取 dataset 节点并替换 source 节点
        ArrayNode dataset = (ArrayNode) chartValueJson.path("dataset");
        for (JsonNode node : dataset) {
            if (node.has("source")) {
                ((ObjectNode) node).set("source", objectMapper.valueToTree(dataList));
                break;
            }
        }

        // 移除集合中第一个对象的第一个元素
        if (!dataList.isEmpty() && !dataList.get(0).isEmpty()) {
            dataList.get(0).remove(0);
        }
        ArrayNode seriesArray = (ArrayNode) chartValueJson.path("series");

        // 计算第一个对象元素数量
        int firstObjectRemainingElements = dataList.isEmpty() ? 0 : dataList.get(0).size();
        System.out.println(firstObjectRemainingElements);

        // 如果 series 字段的对象数量小于第一个集合的数量，循环复制 series 中的对象使其数量相等
        if (seriesArray.size() < firstObjectRemainingElements) {
            JsonNode firstSeriesObject = seriesArray.get(0);
            for (int i = seriesArray.size(); i < firstObjectRemainingElements; i++) {
                seriesArray.add(firstSeriesObject.deepCopy());
            }
        } else {
            // 删除多余的对象
            while (seriesArray.size() > firstObjectRemainingElements) {
                seriesArray.remove(seriesArray.size() - 1);
            }
        }

        return chartValueJson;
    }


    /**
     * 更新dataset节点的source字段
     *
     * @param chartValueJson JSON对象
     * @param lists          数据列表
     * @param objectMapper   ObjectMapper对象
     */
    public static void updateDatasetSource(JsonNode chartValueJson, List<List<String>> lists, ObjectMapper objectMapper) {
        // 获取dataset节点并替换source节点
        JsonNode datasetNode = chartValueJson.path("dataset");

        if (datasetNode.isArray()) {
            ArrayNode dataset = (ArrayNode) datasetNode;
            for (JsonNode node : dataset) {
                if (node.has("source")) {
                    ((ObjectNode) node).set("source", objectMapper.valueToTree(lists));
                    break;
                }
            }
        } else if (datasetNode.isObject()) {
            ObjectNode dataset = (ObjectNode) datasetNode;
            if (dataset.has("source")) {
                dataset.set("source", objectMapper.valueToTree(lists));
            }
        }

        // 移除集合中第一个对象的第一个元素
        if (!lists.isEmpty() && !lists.get(0).isEmpty()) {
            lists.get(0).remove(0);
        }
    }

}
